Week 4: Embedded programming

const int buttonPin = D2;  // pushbutton pin
const int ledPin = D3;     // LED pin

int buttonState = 0;

void setup() {
  Serial.begin(115200);

  // enable internal pull-up resistor
  pinMode(buttonPin, INPUT_PULLUP);

  // LED output
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // read the state of the pushbutton (LOW = pressed)
  buttonState = digitalRead(buttonPin);
  Serial.println(buttonState);

  // button pressed?
  if (buttonState == HIGH) {   // active LOW
    digitalWrite(ledPin, HIGH);  // turn LED on
  } else {
    digitalWrite(ledPin, LOW);   // turn LED off
  }
  delay(1000);
}

Here is what diagram looked like:

Step 3: Arduino

After successfully simulating the program on Wokwi, I moved on to implementing it on the actual XIAO ESP32-C3 hardware on breadboard using the Arduino IDE.I first downloaded the Arduino IDE from the offical website and then downloaded the esp32 board support package from the board manager which took some time to install. The wiring was the same as in the simulation: the button connected to pin D2 and ground, and the LED connected to pin D3 with a current-limiting resistor to ground. I used male to male jumper cables to connect everything with the GND to the breadboard ground rails and the rest as before.

This is what the circuit looked like:

The code is the same as above and I uploaded it to the board and it worked perfectly. When I pressed the button, the LED turned off, and when I released it, the LED turned back on. I also monitored the serial output to see the button state being printed every second.

Here is a video of the setup in action:

Here is a picture of the serial monitor showing the button state:

As you can see the button state is printed as 1 when the button is not pressed and 0 when it is pressed, which confirms that the program is working as expected.

Step 4: MicroPython with Thonny

To satisfy the requirement of using two different workflows, I decided to recreate the exact same physical circuit using MicroPython. For this, I used Thonny, which is an excellent beginner-friendly Python IDE designed specifically for microcontrollers.

Flashing the Firmware

Unlike Arduino, which compiles the C++ code and flashes it directly to the board, MicroPython requires an interpreter to be installed on the microcontroller first.

• I went to the official MicroPython website and downloaded the latest stable `.bin` firmware file for the ESP32-C3.
• In Thonny, I went to Run > Configure interpreter, selected "MicroPython (ESP32)", and selected the COM port for my XIAO.
• I clicked "Install or update MicroPython", selected the `.bin` file I downloaded, and flashed the board.

Here is the flashing process in action:

Writing the Code

A major difference I discovered between the Arduino workflow and MicroPython is how pins are addressed. In Arduino, I used the aliases D2 and D3. However, in MicroPython, you must address the pins by their actual hardware GPIO numbers. Looking back at my datasheet table in Step 1, I saw that D2 maps to GPIO4 and D3 maps to GPIO5.

Here is the MicroPython code to replicate the button and LED logic:

from machine import Pin
import time

# Initialize pins using actual GPIO numbers
# D2 is GPIO4 (Button), D3 is GPIO5 (LED)
button = Pin(4, Pin.IN, Pin.PULL_UP)
led = Pin(5, Pin.OUT)

print("Starting MicroPython Button Test...")

while True:
    # Read button state (1 = unpressed, 0 = pressed due to PULL_UP)
    button_state = button.value()
    print("Button State:", button_state)

    if button_state == 1:
        led.value(1)  # Turn LED on when not pressed
    else:
        led.value(0)  # Turn LED off when pressed
        
    time.sleep(1) # Delay to match the Arduino sketch

Testing the Output

One of the massive advantages of MicroPython is the REPL (Read-Eval-Print Loop). As soon as I clicked the "Run" button in Thonny, the code executed immediately without needing to wait for a compiler. I could see the print() statements updating live in the Thonny shell at the bottom of the screen.

The physical hardware reacted exactly as it did in the Arduino test, successfully proving the second workflow!

In conclusion, this week was a fantastic learning experience. I got to explore the differences between two major programming workflows for microcontrollers and successfully implemented the same functionality using both Arduino and MicroPython. The interactive nature of MicroPython was particularly impressive, allowing for rapid testing and debugging without the need for a compile-upload cycle.

Download Files

• Arduino Code file
• MicroPython Code file

← Back to Main Page